QuickTime - The Beta Release/QuickTime - The Beta Release.iso/Programming Stuff/Interfaces/Movies Interfaces/Movies.h

C/C++ Source or Header | 1991-09-11 | 39.2 KB | 1,253 lines | [TEXT/MPS ]

/************************************************************

Created: Wednesday, August 14, 1991 at 12:23 PM
 Movies.h
 C Interface to the Macintosh Libraries


  Copyright Apple Computer, Inc. 1991
  All rights reserved

************************************************************/


#ifndef __MOVIES__
#define __MOVIES__

#ifndef __QUICKDRAW__
#include <QuickDraw.h>
#endif

#ifndef __ALIASES__
#include <Aliases.h>
#endif

#ifndef __EVENTS__
#include <Events.h>
#endif

#ifndef __COMPONENTS__
#include <Components.h>
#endif

#ifndef __IMAGECOMPRESSION__
#include <ImageCompression.h>
#endif

#ifndef __STANDARDFILE__
#include <StandardFile.h>
#endif



#define gestaltQuickTime 'qtim'

#define MovieFileType 'MooV'

#define VideoMediaType 'vide'
#define SoundMediaType 'soun'

#define DoTheRightThing 0L

struct MovieRecord {
 long data[1];
};

typedef struct MovieRecord MovieRecord;
typedef MovieRecord *Movie;

struct TrackRecord {
 long data[1];
};

typedef struct TrackRecord TrackRecord;
typedef TrackRecord *Track;

struct MediaRecord {
 long data[1];
};

typedef struct MediaRecord MediaRecord;
typedef MediaRecord *Media;

struct UserDataRecord {
 long data[1];
};

typedef struct UserDataRecord UserDataRecord;
typedef UserDataRecord *UserData;

struct TrackEditStateRecord {
 long data[1];
};

typedef struct TrackEditStateRecord TrackEditStateRecord;
typedef TrackEditStateRecord *TrackEditState;

struct MovieEditStateRecord {
 long data[1];
};

typedef struct MovieEditStateRecord MovieEditStateRecord;
typedef MovieEditStateRecord *MovieEditState;


typedef long TimeValue;
typedef long TimeScale;

struct TimeBaseRecord {
 long data[1];
};

typedef struct TimeBaseRecord TimeBaseRecord;
typedef TimeBaseRecord *TimeBase;

struct CallBackRecord {
 long data[1];
};

typedef struct CallBackRecord CallBackRecord;
typedef CallBackRecord *QTCallBack;


struct Int64 {
 long hi;
 long lo;
};

typedef struct Int64 Int64;

struct TimeRecord {
 Int64 value;
 TimeScale scale;
 TimeBase base;
};

typedef struct TimeRecord TimeRecord;

struct PriorityType {
 unsigned short level;
 unsigned short percent;
};

typedef struct PriorityType PriorityType;

struct SampleDescription {
 long descSize;
 long dataFormat;
};

typedef struct SampleDescription SampleDescription;
typedef SampleDescription *SampleDescriptionPtr, **SampleDescriptionHandle;

struct SoundDescription {
 long descSize;
 long dataFormat;
 long resvd1;
 long resvd2;
 short version;
 short revlevel;
 long vendor;
 short numChannels;
 short sampleSize;
 short compressionID;
 short packetSize;
 Fixed sampleRate;
};

typedef struct SoundDescription SoundDescription;
typedef SoundDescription *SoundDescriptionPtr, **SoundDescriptionHandle;


enum {movieProgressOpen = 0,movieProgressUpdatePercent = 1,movieProgressClose = 2};
typedef unsigned char movieProgressMessages;

enum {progressOpFlatten = 1,progressOpInsertTrackSegment = 2,progressOpInsertMovieSegment = 3,
 progressOpPaste = 4,progressOpAddMovieSelection = 5,progressOpCopy = 6,
 progressOpCut = 7,progressOpLoadMovieIntoRam = 8,progressOpLoadTrackIntoRam = 9,
    progressOpLoadMediaIntoRam = 10};
typedef unsigned char movieProgressOperations;




typedef pascal Boolean  (*MovieProgressProcPtr) (Movie m, short message, short whatOperation,
           Fixed percentDone, long refCon);

typedef pascal OSErr (*MovieRgnCoverProc)(Movie m, RgnHandle changedRgn, long refcon);

typedef Handle MediaInformationHandle;
typedef ComponentInstance MediaHandler;
typedef ComponentInstance DataHandler;
typedef ComponentResult HandlerError;
typedef ComponentInstance MovieController;

typedef pascal void (*ErrorProcPtr)(OSErr theErr, long refcon);

typedef pascal Boolean (*MoviePreviewCallOutProc)(long refcon);


enum {newMovieActive = 1<<0,newMovieDontResolveDataRefs = 1<<1,newMovieDontAskUnresolvedDataRefs = 1<<2};
typedef unsigned char newMovieFlagsEnum;

enum {trackUsageInMovie = 1<<1,trackUsageInPreview = 1<<2,trackUsageInPoster = 1<<3};
typedef unsigned char trackUsageEnum;

enum {mediaSampleNotSync = 1};
typedef unsigned char mediaSampleFlagsEnum;

enum {nextTimeMediaSample = 1<<0,nextTimeMediaEdit = 1<<1,nextTimeTrackEdit = 1<<2,
 nextTimeSyncSample = 1<<3,nextTimeEdgeOK = 1<<14,nextTimeIgnoreActiveSegment = 1<<15};
typedef unsigned short nextTimeFlagsEnum;

enum {createMovieFileDeleteCurFile = 1L<<31,createMovieFileDontCreateMovie = 1L<<30,
 createMovieFileDontOpenFile = 1L<<29};
typedef unsigned long createMovieFileFlagsEnum;

enum {flattenAddMovieToDataFork = 1L<<0,flattenActiveTracksOnly = 1L<<2,
 flattenDontInterleaveFlatten = 1L<<3};
typedef unsigned char movieFlattenFlagsEnum;

enum {movieScrapDontZeroScrap = 1<<0,movieScrapOnlyPutMovie = 1<<1};
typedef unsigned char movieScrapFlagsEnum;

enum {hintsScrubMode = 1<<0};
typedef unsigned char playHintsEnum;






#ifdef __cplusplus
extern "C" {
#endif
/*  Initialization Routines  */
pascal OSErr EnterMovies(void)
 = {0x303C,0x1,0xAAAA};
pascal void ExitMovies(void)
 = {0x303C,0x2,0xAAAA};

/*  error Routines  */
pascal OSErr GetMoviesError(void)
 = {0x303C,0x3,0xAAAA};
pascal void ClearMoviesStickyError(void)
 = {0x303C,0xDE,0xAAAA};
pascal OSErr GetMoviesStickyError(void)
 = {0x303C,0x4,0xAAAA};

pascal void SetMoviesErrorProc(ErrorProcPtr errProc,long refcon)
 = {0x303C,0xEF,0xAAAA};

pascal ComponentResult GetTrackStatus(Track t)
 = {0x303C,0x172,0xAAAA};
pascal ComponentResult GetMovieStatus(Movie m,Track *firstProblemTrack)
 = {0x303C,0x173,0xAAAA};

/*  Playback Routines  */
pascal void MoviesTask(Movie m,long maxMilliSecToUse)
 = {0x303C,0x5,0xAAAA};

pascal void StartMovie(Movie m)
 = {0x303C,0xB,0xAAAA};
pascal void StopMovie(Movie m)
 = {0x303C,0xC,0xAAAA};
pascal void GotoBeginningOfMovie(Movie m)
 = {0x303C,0xD,0xAAAA};
pascal void GotoEndOfMovie(Movie m)
 = {0x303C,0xE,0xAAAA};
pascal Boolean IsMovieDone(Movie m)
 = {0x303C,0xDD,0xAAAA};

pascal Boolean GetMoviePreviewMode(Movie m)
 = {0x303C,0xF,0xAAAA};
pascal void SetMoviePreviewMode(Movie m,Boolean usePreview)
 = {0x303C,0x10,0xAAAA};
pascal void ShowMoviePoster(Movie m)
 = {0x303C,0x11,0xAAAA};

pascal void GetMoviePriority(Movie m,PriorityType *priority)
 = {0x303C,0x13,0xAAAA};
pascal void SetMoviePriority(Movie m,const PriorityType *priority)
 = {0x303C,0x14,0xAAAA};

pascal void GetMovieGWorld(Movie m,CGrafPtr *port,GDHandle *gdh)
 = {0x303C,0x15,0xAAAA};
pascal void SetMovieGWorld(Movie m,CGrafPtr port,GDHandle gdh)
 = {0x303C,0x16,0xAAAA};

pascal OSErr PrerollMovie(Movie m,TimeValue time,Fixed Rate)
 = {0x303C,0x6,0xAAAA};
pascal OSErr LoadMovieIntoRam(Movie m,TimeValue time,TimeValue duration,
 long flags)
 = {0x303C,0x7,0xAAAA};
pascal OSErr LoadTrackIntoRam(Track t,TimeValue time,TimeValue duration,
 long flags)
 = {0x303C,0x16E,0xAAAA};
pascal OSErr LoadMediaIntoRam(Media m,TimeValue time,TimeValue duration,
 long flags)
 = {0x303C,0x8,0xAAAA};

pascal void SetMovieActive(Movie m,Boolean active)
 = {0x303C,0x9,0xAAAA};
pascal Boolean GetMovieActive(Movie m)
 = {0x303C,0xA,0xAAAA};

pascal void PlayMoviePreview(Movie m,MoviePreviewCallOutProc callOutProc,
 long refcon)
 = {0x303C,0xF2,0xAAAA};

/*  Movie PICT Routines  */
pascal PicHandle GetMoviePict(Movie m,TimeValue time)
 = {0x303C,0x1D,0xAAAA};
pascal PicHandle GetTrackPict(Track t,TimeValue time)
 = {0x303C,0x1E,0xAAAA};

pascal PicHandle GetMoviePosterPict(Movie m)
 = {0x303C,0xF7,0xAAAA};

/*  movie TimeBase Routines  */
pascal TimeBase GetMovieTimeBase(Movie m)
 = {0x303C,0x12,0xAAAA};

pascal void SetMovieMasterTimeBase(Movie m,TimeBase tb,const TimeRecord *slaveZero)
 = {0x303C,0x167,0xAAAA};
pascal void SetMovieMasterClock(Movie m,Component clockMeister,const TimeRecord *slaveZero)
 = {0x303C,0x168,0xAAAA};

/*  spatial movie Routines  */
pascal void GetMovieBox(Movie m,Rect *boxRect)
 = {0x303C,0xF9,0xAAAA};
pascal void SetMovieBox(Movie m,const Rect *boxRect)
 = {0x303C,0xFA,0xAAAA};

/*  movie display clip  */
pascal RgnHandle GetMovieDisplayClipRgn(Movie m)
 = {0x303C,0xFC,0xAAAA};
pascal void SetMovieDisplayClipRgn(Movie m,RgnHandle theClip)
 = {0x303C,0xFD,0xAAAA};

/*  movie src clip  */
pascal RgnHandle GetMovieSrcClipRgn(Movie m)
 = {0x303C,0x100,0xAAAA};
pascal void SetMovieSrcClipRgn(Movie m,RgnHandle theClip)
 = {0x303C,0x101,0xAAAA};

/*  track src clip  */
pascal RgnHandle GetTrackSrcClipRgn(Track t)
 = {0x303C,0x102,0xAAAA};
pascal void SetTrackSrcClipRgn(Track t,RgnHandle theClip)
 = {0x303C,0x103,0xAAAA};

/*  bounds in display space  */
pascal RgnHandle GetMovieDisplayBoundsRgn(Movie m)
 = {0x303C,0xFB,0xAAAA};
pascal RgnHandle GetTrackMovieDisplayBoundsRgn(Track t)
 = {0x303C,0x112,0xAAAA};

/*  bounds in movie space  */
pascal RgnHandle GetMovieSrcBoundsRgn(Movie m)
 = {0x303C,0xFE,0xAAAA};
pascal RgnHandle GetTrackMovieSrcBoundsRgn(Track t)
 = {0x303C,0xFF,0xAAAA};

/*  bounds in track space  */
pascal RgnHandle GetTrackSrcBoundsRgn(Track t)
 = {0x303C,0x111,0xAAAA};

/*  movie poster box  */
pascal void GetPosterBox(Movie m,Rect *boxRect)
 = {0x303C,0x16F,0xAAAA};
pascal void SetPosterBox(Movie m,const Rect *boxRect)
 = {0x303C,0x170,0xAAAA};

/*  movie/track bounds over a range of time  */
pascal RgnHandle GetMovieSegmentDisplayBoundsRgn(Movie m,TimeValue time,
 TimeValue duration)
 = {0x303C,0x16C,0xAAAA};
pascal RgnHandle GetTrackSegmentMovieDisplayBoundsRgn(Track t,TimeValue time,
 TimeValue duration)
 = {0x303C,0x16B,0xAAAA};

pascal void SetMovieCoverProcs(Movie m,MovieRgnCoverProc uncoverProc,MovieRgnCoverProc coverProc,
 long refCon)
 = {0x303C,0x179,0xAAAA};

/*  mattes - always in track space  */
pascal PixMapHandle GetTrackSrcMatte(Track t)
 = {0x303C,0x115,0xAAAA};
pascal void SetTrackSrcMatte(Track t,PixMapHandle theMatte)
 = {0x303C,0x116,0xAAAA};
pascal void DisposeMatte(PixMapHandle theMatte)
 = {0x303C,0x14A,0xAAAA};

/*  movie creation Routines  */
pascal OSErr NewMovieFromHandle(Movie *m,Handle h,short newMovieFlags,Boolean *dataRefWasChanged)
 = {0x303C,0xF1,0xAAAA};
pascal OSErr PutMovieIntoHandle(Movie m,Handle h)
 = {0x303C,0x22,0xAAAA};

pascal Movie NewMovie(long newMovieFlags)
 = {0x303C,0x187,0xAAAA};
pascal void DisposeMovie(Movie m)
 = {0x303C,0x23,0xAAAA};

/*  Movie Routines  */
pascal unsigned long GetMovieCreationTime(Movie m)
 = {0x303C,0x26,0xAAAA};
pascal unsigned long GetMovieModificationTime(Movie m)
 = {0x303C,0x27,0xAAAA};

pascal TimeScale GetMovieTimeScale(Movie m)
 = {0x303C,0x29,0xAAAA};
pascal void SetMovieTimeScale(Movie m,TimeScale timeScale)
 = {0x303C,0x2A,0xAAAA};

pascal TimeValue GetMovieDuration(Movie m)
 = {0x303C,0x2B,0xAAAA};

pascal Fixed GetMovieRate(Movie m)
 = {0x303C,0x2C,0xAAAA};
pascal void SetMovieRate(Movie m,Fixed rate)
 = {0x303C,0x2D,0xAAAA};

pascal Fixed GetMoviePreferredRate(Movie m)
 = {0x303C,0xF3,0xAAAA};
pascal void SetMoviePreferredRate(Movie m,Fixed rate)
 = {0x303C,0xF4,0xAAAA};

pascal short GetMoviePreferredVolume(Movie m)
 = {0x303C,0xF5,0xAAAA};
pascal void SetMoviePreferredVolume(Movie m,short volume)
 = {0x303C,0xF6,0xAAAA};

pascal short GetMovieVolume(Movie m)
 = {0x303C,0x2E,0xAAAA};
pascal void SetMovieVolume(Movie m,short volume)
 = {0x303C,0x2F,0xAAAA};

pascal void GetMovieMatrix(Movie m,MatrixRecord *matrix)
 = {0x303C,0x31,0xAAAA};
pascal void SetMovieMatrix(Movie m,const MatrixRecord *matrix)
 = {0x303C,0x32,0xAAAA};

pascal void GetMoviePreviewTime(Movie m,TimeValue *previewTime,TimeValue *previewDuration)
 = {0x303C,0x33,0xAAAA};
pascal void SetMoviePreviewTime(Movie m,TimeValue previewTime,TimeValue previewDuration)
 = {0x303C,0x34,0xAAAA};

pascal TimeValue GetMoviePosterTime(Movie m)
 = {0x303C,0x35,0xAAAA};
pascal void SetMoviePosterTime(Movie m,TimeValue posterTime)
 = {0x303C,0x36,0xAAAA};

pascal void GetMovieSelection(Movie m,TimeValue *selectionTime,TimeValue *selectionDuration)
 = {0x303C,0x37,0xAAAA};
pascal void SetMovieSelection(Movie m,TimeValue selectionTime,TimeValue selectionDuration)
 = {0x303C,0x38,0xAAAA};

pascal void SetMovieActiveSegment(Movie m,TimeValue startTime,TimeValue duration)
 = {0x303C,0x15C,0xAAAA};
pascal void GetMovieActiveSegment(Movie m,TimeValue *startTime,TimeValue *duration)
 = {0x303C,0x15D,0xAAAA};

pascal TimeValue GetMovieTime(Movie m,TimeRecord *currentTime)
 = {0x303C,0x39,0xAAAA};
pascal void SetMovieTime(Movie m,const TimeRecord *newtime)
 = {0x303C,0x3C,0xAAAA};
pascal void SetMovieTimeValue(Movie m,TimeValue newtime)
 = {0x303C,0x3D,0xAAAA};

pascal UserData GetMovieUserData(Movie m)
 = {0x303C,0x3E,0xAAAA};

pascal void SetMoviePlayHints(Movie movie,long flags,long flagsMask)
 = {0x303C,0x1A1,0xAAAA};

/*  Movie/Track/Media finding Routines  */
pascal long GetMovieTrackCount(Movie m)
 = {0x303C,0x3F,0xAAAA};
pascal Track GetMovieTrack(Movie m,long trackID)
 = {0x303C,0x40,0xAAAA};

pascal Track GetMovieIndTrack(Movie m,long index)
 = {0x303C,0x117,0xAAAA};

pascal long GetTrackID(Track t)
 = {0x303C,0x127,0xAAAA};

pascal Movie GetTrackMovie(Track t)
 = {0x303C,0xD0,0xAAAA};

pascal Media GetTrackMedia(Track t)
 = {0x303C,0x62,0xAAAA};
pascal Track GetMediaTrack(Media m)
 = {0x303C,0xC5,0xAAAA};

/*  Track creation Routines  */
pascal Track NewMovieTrack(Movie m,Fixed width,Fixed height,short trackVolume)
 = {0x303C,0x188,0xAAAA};
pascal void DisposeMovieTrack(Track t)
 = {0x303C,0x42,0xAAAA};

/*  Track Routines  */
pascal unsigned long GetTrackCreationTime(Track t)
 = {0x303C,0x43,0xAAAA};
pascal unsigned long GetTrackModificationTime(Track t)
 = {0x303C,0x44,0xAAAA};

pascal Boolean GetTrackEnabled(Track t)
 = {0x303C,0x45,0xAAAA};
pascal void SetTrackEnabled(Track t,Boolean isEnabled)
 = {0x303C,0x46,0xAAAA};

pascal long GetTrackUsage(Track t)
 = {0x303C,0x47,0xAAAA};
pascal void SetTrackUsage(Track t,long usage)
 = {0x303C,0x48,0xAAAA};

pascal TimeValue GetTrackDuration(Track t)
 = {0x303C,0x4B,0xAAAA};

pascal TimeValue GetTrackOffset(Track t)
 = {0x303C,0x4C,0xAAAA};
pascal void SetTrackOffset(Track t,TimeValue offset)
 = {0x303C,0x4D,0xAAAA};

pascal void GetTrackPriority(Track t,PriorityType *priority)
 = {0x303C,0x4E,0xAAAA};
pascal void SetTrackPriority(Track t,const PriorityType *priority)
 = {0x303C,0x4F,0xAAAA};

pascal short GetTrackLayer(Track t)
 = {0x303C,0x50,0xAAAA};
pascal void SetTrackLayer(Track t,short layer)
 = {0x303C,0x51,0xAAAA};

pascal Track GetTrackAlternate(Track t)
 = {0x303C,0x52,0xAAAA};
pascal void SetTrackAlternate(Track t,Track alternateT)
 = {0x303C,0x53,0xAAAA};

pascal short GetTrackVolume(Track t)
 = {0x303C,0x54,0xAAAA};
pascal void SetTrackVolume(Track t,short volume)
 = {0x303C,0x55,0xAAAA};

pascal void GetTrackMatrix(Track t,MatrixRecord *matrix)
 = {0x303C,0x56,0xAAAA};
pascal void SetTrackMatrix(Track t,const MatrixRecord *matrix)
 = {0x303C,0x57,0xAAAA};

pascal void GetTrackDimensions(Track t,Fixed *width,Fixed *height)
 = {0x303C,0x5D,0xAAAA};
pascal void SetTrackDimensions(Track t,Fixed width,Fixed height)
 = {0x303C,0x5E,0xAAAA};

pascal UserData GetTrackUserData(Track t)
 = {0x303C,0x5F,0xAAAA};

/*  Media creation Routines  */
pascal Media NewTrackMedia(Track t,OSType mediaType,TimeScale timeScale,
 Handle dataRef,OSType dataRefType)
 = {0x303C,0x18E,0xAAAA};
pascal void DisposeTrackMedia(Media m)
 = {0x303C,0x61,0xAAAA};

/*  Media Routines  */
pascal unsigned long GetMediaCreationTime(Media m)
 = {0x303C,0x66,0xAAAA};
pascal unsigned long GetMediaModificationTime(Media m)
 = {0x303C,0x67,0xAAAA};

pascal TimeScale GetMediaTimeScale(Media m)
 = {0x303C,0x68,0xAAAA};
pascal void SetMediaTimeScale(Media m,TimeScale timeScale)
 = {0x303C,0x69,0xAAAA};

pascal TimeValue GetMediaDuration(Media m)
 = {0x303C,0x6A,0xAAAA};

pascal short GetMediaLanguage(Media m)
 = {0x303C,0x6B,0xAAAA};
pascal void SetMediaLanguage(Media m,short language)
 = {0x303C,0x6C,0xAAAA};

pascal short GetMediaQuality(Media m)
 = {0x303C,0x6D,0xAAAA};
pascal void SetMediaQuality(Media m,short quality)
 = {0x303C,0x6E,0xAAAA};

pascal UserData GetMediaUserData(Media m)
 = {0x303C,0x70,0xAAAA};

pascal void SetMediaPlayHints(Movie movie,long flags,long flagsMask)
 = {0x303C,0x1A2,0xAAAA};

/*  Media Handler Routines  */
pascal MediaHandler GetMediaHandler(Media m)
 = {0x303C,0x71,0xAAAA};
pascal OSErr SetMediaHandler(Media m,MediaHandler mH)
 = {0x303C,0x190,0xAAAA};

pascal void GetMediaHandlerDescription(Media m,OSType *mediaType,const Str255 originalName,
 OSType *originalManufacturer)
 = {0x303C,0x6F,0xAAAA};

#ifdef __cplusplus
}
#endif
enum {dataRefSelfReference = 1<<0,dataRefWasNotResolved = 1<<1};
typedef unsigned char dataRefAttributesFlags;


#ifdef __cplusplus
extern "C" {
#endif
/*  Media dataRef Routines  */
pascal OSErr GetMediaDataRef(Media m,short index,Handle *dataRef,OSType *dataRefType,
 long *dataRefAttributes)
 = {0x303C,0x197,0xAAAA};
pascal OSErr AddMediaDataRef(Media m,short *index,Handle dataRef,OSType dataRefType)
 = {0x303C,0x198,0xAAAA};

pascal OSErr GetMediaDataRefCount(Media m,short *count)
 = {0x303C,0x199,0xAAAA};

/*  Media data handler Routines  */
pascal DataHandler GetMediaDataHandler(Media m,short index)
 = {0x303C,0x19F,0xAAAA};
pascal OSErr SetMediaDataHandler(Media m,short index,DataHandler dataHandler)
 = {0x303C,0x1A0,0xAAAA};

pascal void GetMediaDataHandlerDescription(Media m,short index,OSType *dhType,
 Str255 creatorName,OSType *creatorManufacturer)
 = {0x303C,0x19E,0xAAAA};

/*  Media sample Routines  */
pascal long GetMediaSampleDescriptionCount(Media m)
 = {0x303C,0x77,0xAAAA};
pascal void GetMediaSampleDescription(Media m,long index,SampleDescriptionHandle descH)
 = {0x303C,0x78,0xAAAA};
pascal long GetMediaSampleCount(Media m)
 = {0x303C,0x79,0xAAAA};
pascal void SampleNumToMediaTime(Media m,long logicalSampleNum,TimeValue *sampleTime,
 TimeValue *sampleDuration)
 = {0x303C,0x7A,0xAAAA};
pascal void MediaTimeToSampleNum(Media m,TimeValue time,long *sampleNum,
 TimeValue *sampleTime,TimeValue *sampleDuration)
 = {0x303C,0x7B,0xAAAA};

pascal OSErr AddMediaSample(Media m,Handle dataIn,long inOffset,unsigned long size,
 TimeValue durationPerSample,SampleDescriptionHandle sampleDescriptionH,
 long numberOfSamples,short sampleFlags,TimeValue *sampleTime)
 = {0x303C,0x7C,0xAAAA};
pascal OSErr AddMediaSampleReference(Media m,long dataOffset,unsigned long size,
 TimeValue durationPerSample,SampleDescriptionHandle sampleDescriptionH,
 long numberOfSamples,short sampleFlags,TimeValue *sampleTime)
 = {0x303C,0x7D,0xAAAA};
pascal OSErr GetMediaSample(Media m,Handle dataOut,long maxSizeToGrow,long *size,
 TimeValue time,TimeValue *sampleTime,TimeValue *durationPerSample,SampleDescriptionHandle sampleDescriptionH,
 long *sampleDescriptionIndex,long maxNumberOfSamples,long *numberOfSamples,
 short *sampleFlags)
 = {0x303C,0x7E,0xAAAA};
pascal OSErr GetMediaSampleReference(Media m,long *dataOffset,long *size,
 TimeValue time,TimeValue *sampleTime,TimeValue *durationPerSample,SampleDescriptionHandle sampleDescriptionH,
 long *sampleDescriptionIndex,long maxNumberOfSamples,long *numberOfSamples,
 short *sampleFlags)
 = {0x303C,0x7F,0xAAAA};
pascal void SetPreferredMediaChunkSize(Media m,long minChunkSize,long maxChunkSize,
 long padSize)
 = {0x303C,0x80,0xAAAA};

/*  High level editing Routines  */
pascal Movie CutMovieSelection(Movie m)
 = {0x303C,0x8D,0xAAAA};
pascal Movie CopyMovieSelection(Movie m)
 = {0x303C,0x8E,0xAAAA};
pascal void PasteMovieSelection(Movie m,Movie src)
 = {0x303C,0x8F,0xAAAA};
pascal void AddMovieSelection(Movie m,Movie src)
 = {0x303C,0x152,0xAAAA};
pascal void ClearMovieSelection(Movie m)
 = {0x303C,0xE1,0xAAAA};

/*  Middle-level Editing Routines  */
pascal OSErr InsertTrackSegment(Track srcTrack,Track dstTrack,TimeValue srcIn,
 TimeValue srcDuration,TimeValue dstIn)
 = {0x303C,0x85,0xAAAA};
pascal OSErr InsertMovieSegment(Movie srcMovie,Movie dstMovie,TimeValue srcIn,
 TimeValue srcDuration,TimeValue dstIn)
 = {0x303C,0x86,0xAAAA};
pascal OSErr InsertEmptyTrackSegment(Track dstTrack,TimeValue dstIn,TimeValue dstDuration)
 = {0x303C,0x87,0xAAAA};
pascal OSErr InsertEmptyMovieSegment(Movie dstMovie,TimeValue dstIn,TimeValue dstDuration)
 = {0x303C,0x88,0xAAAA};
pascal OSErr DeleteTrackSegment(Track t,TimeValue dstIn,TimeValue duration)
 = {0x303C,0x89,0xAAAA};
pascal OSErr DeleteMovieSegment(Movie m,TimeValue dstIn,TimeValue duration)
 = {0x303C,0x8A,0xAAAA};
pascal OSErr ScaleTrackSegment(Track t,TimeValue dstIn,TimeValue oldDuration,
 TimeValue newDuration)
 = {0x303C,0x8B,0xAAAA};
pascal OSErr ScaleMovieSegment(Movie m,TimeValue dstIn,TimeValue oldDuration,
 TimeValue newDuration)
 = {0x303C,0x8C,0xAAAA};

pascal OSErr CopyTrackSettings(Track srcTrack,Track dstTrack)
 = {0x303C,0x153,0xAAAA};
pascal OSErr CopyMovieSettings(Movie srcMovie,Movie dstMovie)
 = {0x303C,0x154,0xAAAA};

/*  low-level Editing Routines  */
pascal OSErr InsertMediaIntoTrack(Track t,TimeValue trackStart,TimeValue mediaTime,
 TimeValue mediaDuration,Fixed mediaRate)
 = {0x303C,0x183,0xAAAA};

pascal OSErr BeginMediaEdits(Media m)
 = {0x303C,0x72,0xAAAA};
pascal OSErr EndMediaEdits(Media m)
 = {0x303C,0x73,0xAAAA};

/*  movie & track edit state Routines  */
pascal MovieEditState NewMovieEditState(Movie m)
 = {0x303C,0x104,0xAAAA};
pascal OSErr UseMovieEditState(Movie m,MovieEditState toState)
 = {0x303C,0x105,0xAAAA};
pascal OSErr DisposeMovieEditState(MovieEditState state)
 = {0x303C,0x106,0xAAAA};

pascal TrackEditState NewTrackEditState(Track t)
 = {0x303C,0x107,0xAAAA};
pascal OSErr UseTrackEditState(Track t,TrackEditState state)
 = {0x303C,0x108,0xAAAA};
pascal OSErr DisposeTrackEditState(TrackEditState state)
 = {0x303C,0x109,0xAAAA};

/*  Miscellaneous Routines  */
pascal TimeValue TrackTimeToMediaTime(TimeValue value,Track t)
 = {0x303C,0x96,0xAAAA};

pascal long GetMovieDataSize(Movie m,TimeValue startTime,TimeValue duration)
 = {0x303C,0x98,0xAAAA};
pascal long GetTrackDataSize(Track t,TimeValue startTime,TimeValue duration)
 = {0x303C,0x149,0xAAAA};
pascal long GetMediaDataSize(Media m,TimeValue startTime,TimeValue duration)
 = {0x303C,0x99,0xAAAA};

pascal Boolean PtInMovie(Movie m,Point pt)
 = {0x303C,0x9A,0xAAAA};
pascal Boolean PtInTrack(Track t,Point pt)
 = {0x303C,0x9B,0xAAAA};

pascal OSErr UpdateMovie(Movie m)
 = {0x303C,0x1F,0xAAAA};

/*  Alternate Group Selection Routines  */
pascal void SetMovieLanguage(Movie m,long language)
 = {0x303C,0x9C,0xAAAA};

pascal void SetAutoTrackAlternatesEnabled(Movie m,Boolean enable)
 = {0x303C,0x15E,0xAAAA};
pascal void SelectMovieAlternates(Movie m)
 = {0x303C,0x15F,0xAAAA};

/*  UserData Routines  */
pascal OSErr GetUserData(UserData u,Handle data,long pType,long index)
 = {0x303C,0x9E,0xAAAA};
pascal OSErr AddUserData(UserData u,Handle data,long pType)
 = {0x303C,0x9F,0xAAAA};
pascal OSErr RemoveUserData(UserData u,long pType,long index)
 = {0x303C,0xA0,0xAAAA};
pascal short CountUserDataType(UserData userDataH,long pType)
 = {0x303C,0x14B,0xAAAA};
pascal OSErr AddUserDataText(UserData u,Handle data,long pType,long index,
 short itlRegionTag)
 = {0x303C,0x14C,0xAAAA};
pascal OSErr GetUserDataText(UserData u,Handle data,long pType,long index,
 short itlRegionTag)
 = {0x303C,0x14D,0xAAAA};
pascal OSErr RemoveUserDataText(UserData u,long pType,long index,short itlRegionTag)
 = {0x303C,0x14E,0xAAAA};

/*  interesting time Routines  */
pascal void GetMediaNextInterestingTime(Media m,short interestingTimeFlags,
 TimeValue time,Fixed rate,TimeValue *interestingTime,TimeValue *interestingDuration)
 = {0x303C,0x16D,0xAAAA};
pascal void GetTrackNextInterestingTime(Track t,short interestingTimeFlags,
 TimeValue time,Fixed rate,TimeValue *interestingTime,TimeValue *interestingDuration)
 = {0x303C,0xE2,0xAAAA};
pascal void GetMovieNextInterestingTime(Movie m,short interestingTimeFlags,
 short numMediaTypes,const OSType *whichMediaTypes,TimeValue time,Fixed rate,
 TimeValue *interestingTime,TimeValue *interestingDuration)
 = {0x303C,0x10E,0xAAAA};

/*  movie file Routines  */
pascal OSErr CreateMovieFile(const FSSpec *fileSpec,OSType creator,ScriptCode scriptTag,
 long createMovieFileFlags,short *resRefNum,Movie *newMovie)
 = {0x303C,0x191,0xAAAA};
pascal OSErr DeleteMovieFile(const FSSpec *fileSpec)
 = {0x303C,0x175,0xAAAA};

pascal OSErr OpenMovieFile(const FSSpec *fileSpec,short *resRefNum,char perms)
 = {0x303C,0x192,0xAAAA};
pascal OSErr CloseMovieFile(short resRefNum)
 = {0x303C,0xD5,0xAAAA};
#ifdef __cplusplus
}
#endif
enum {

 movieInDataForkResID = -1            /* magic res ID */

};

#ifdef __cplusplus
extern "C" {
#endif
pascal OSErr NewMovieFromFile(Movie *m,short resRefNum,short *resId,char *resName,
 short newMovieFlags,Boolean *dataRefWasChanged)
 = {0x303C,0xF0,0xAAAA};

pascal OSErr AddMovieResource(Movie m,short resRefNum,short *resId,const char *resName)
 = {0x303C,0xD7,0xAAAA};
pascal OSErr RemoveMovieResource(short resRefNum,short resId)
 = {0x303C,0x176,0xAAAA};
pascal OSErr UpdateMovieResource(Movie m,short resRefNum,short resId,const char *resName)
 = {0x303C,0xD8,0xAAAA};

pascal Boolean HasMovieChanged(Movie m)
 = {0x303C,0xD9,0xAAAA};
pascal void ClearMovieChanged(Movie m)
 = {0x303C,0x113,0xAAAA};

pascal void FlattenMovie(Movie m,long movieFlattenFlags,const FSSpec *theFile,
 OSType creator,ScriptCode scriptTag,long createMovieFileFlags,short *resId,
 const char *resName)
 = {0x303C,0x19B,0xAAAA};
pascal Movie FlattenMovieData(Movie m,long movieFlattenFlags,const FSSpec *theFile,
 OSType creator,ScriptCode scriptTag,long createMovieFileFlags)
 = {0x303C,0x19C,0xAAAA};
pascal void SetMovieProgressProc(Movie m,MovieProgressProcPtr p,long refCon)
 = {0x303C,0x19A,0xAAAA};

pascal OSErr PutMovieOnScrap(Movie m,long movieScrapFlags)
 = {0x303C,0x18C,0xAAAA};
pascal Movie NewMovieFromScrap(long newMovieFlags)
 = {0x303C,0x18D,0xAAAA};

/*  Video Media Routines  */
pascal HandlerError GetVideoMediaGraphicsMode(MediaHandler mh,long *graphicsMode,
 RGBColor *opColor)
 = {0x2F3C,0x8,0x101,0x7000,0xA82A};
pascal HandlerError SetVideoMediaGraphicsMode(MediaHandler mh,long graphicsMode,
 const RGBColor *opColor)
 = {0x2F3C,0x8,0x102,0x7000,0xA82A};

/*  Sound Media Routines  */
pascal HandlerError GetSoundMediaBalance(MediaHandler mh,short *balance)
 = {0x2F3C,0x4,0x101,0x7000,0xA82A};
pascal HandlerError SetSoundMediaBalance(MediaHandler mh,short balance)
 = {0x2F3C,0x2,0x102,0x7000,0xA82A};

#ifdef __cplusplus
}
#endif


enum {
/* Dialog box IDs for previewing */
 spGetDlgID_Sys6 = -3998,
 spGetDlgID_Sys7 = -6039,
/* Item numbers for the Previewing Dialog Boxes */
 spItemReserved = 10,
 spItemPreviewArea = 11,
 spItemPreviewStatText = 12,
 spItemVertDividerPict = 13,
 spItemFileInfoField = 14,
 spItemCreatePreviewButton = 15,
 spFirstPreviewItemNumber = spItemPreviewArea,
 spLastPreviewItemNumber = spItemCreatePreviewButton
};

#ifdef __cplusplus
extern "C" {
#endif

pascal void StandardGetFilePreview(FileFilterProcPtr fileFilter,short numTypes,
 SFTypeList typeList,StandardFileReply *reply)
 = {0x3F3C,0x0009,0xA9EA};
pascal void CustomGetFilePreview(FileFilterYDProcPtr fileFilter,short numTypes,
 SFTypeList typeList,StandardFileReply *reply,short dlgID,Point    where,
 DlgHookYDProcPtr dlgHook,ModalFilterYDProcPtr filterProc,short *activeList,
 ActivateYDProcPtr activateProc,void *yourDataPtr)
 ={ 0x3F3C,0x000A,0xA9EA};

#ifdef __cplusplus
}
#endif


enum {

 couldNotResolveDataRef = -2000,
 badImageDescription = -2001,
 badPublicMovieAtom = -2002,
 cantFindHandler = -2003,
 cantOpenHandler = -2004,
 badComponentType = -2005,
 noMediaHandler = -2006,
 noDataHandler = -2007,
 invalidMedia = -2008,
 invalidTrack = -2009,
 invalidMovie = -2010,
 invalidSampleTable = -2011,
 invalidDataRef = -2012,
 invalidHandler = -2013,
 invalidDuration = -2014,
 invalidTime = -2015,
 cantPutPublicMovieAtom = -2016,
 badEditList = -2017,
 mediaTypesDontMatch = -2018,
 progressProcAborted = -2019
};
enum {
 movieToolboxUnitialized = -2020,
 wfFileNotFound = -2021,
 cantCreateSingleForkFile = -2022,
 invalidEditState = -2023,
 nonMatchingEditState = -2024,
 staleEditState = -2025,
 userDataItemNotFound = -2026,
 maxSizeToGrowTooSmall = -2027,
 badTrackIndex = -2028,
 trackIDNotFound = -2029,
 trackNotInMovie = -2030,
 timeNotInTrack = -2031,
 timeNotInMedia = -2032,
 badEditIndex = -2033,
 internalQuickTimeError = -2034,
 cantEnableTrack = -2035,
 invalidRect = -2036,
 invalidSampleNum = -2037,
 invalidChunkNum = -2038,
 invalidSampleDescIndex = -2039
};
enum {
 invalidChunkCache = -2040,
 invalidSampleDescription = -2041,

/* this should probably be in its own range for data handlers */
 dataNotOpenForRead = -2042,
 dataNotOpenForWrite = -2043,
 dataAlreadyOpenForWrite = -2044,
 dataAlreadyClosed = -2045,
 endOfDataReached = -2046,
 dataNoDataRef = -2047,

/* private errors */
 noMovieInDataFork = -2048,            /* this is a private error */

 invalidDataRefContainer = -2049,
 badDataRefIndex = -2050
};

/* TimeBase Routines */
enum {loopTimeBase = 1};
typedef unsigned char TimeBaseFlags;

enum {
 triggerTimeFwd       = 0x0001,      /* when curTime exceeds triggerTime going forward */
 triggerTimeBwd       = 0x0002,      /* when curTime exceeds triggerTime going backwards */
 triggerTimeEither    = 0x0003,      /* when curTime exceeds triggerTime going either direction */
 triggerRateLT        = 0x0004,      /* when rate changes to less than trigger value */
 triggerRateGT        = 0x0008,      /* when rate changes to greater than trigger value */
 triggerRateEqual     = 0x0010,      /* when rate changes to equal trigger value */
 triggerRateLTE       = triggerRateLT | triggerRateEqual,
 triggerRateGTE       = triggerRateGT | triggerRateEqual,
 triggerRateNotEqual  = triggerRateGT | triggerRateEqual | triggerRateLT,
 triggerRateChange    = 0
};
typedef unsigned char QTCallBackFlags;

enum {timeBaseBeforeStartTime = 1,timeBaseAfterStopTime = 2};
typedef unsigned char TimeBaseStatus;

enum {callBackAtTime = 1,callBackAtRate = 2,callBackAtTimeJump = 3,callBackAtInterrupt = 0x8000};
typedef unsigned short QTCallBackType;


typedef pascal void (*QTCallBackProc)(QTCallBack cb,long refCon);

enum {

 qtcbNeedsRateChanges = 1,
 qtcbNeedsTimeChanges = 2
};

/* CallBack equates */
struct QTCallBackHeader {
 long callBackFlags;
 long reserved1;
 char qtPrivate[40];
};

typedef struct QTCallBackHeader QTCallBackHeader;


#ifdef __cplusplus
extern "C" {
#endif
/*  TimeBase Routines  */
pascal TimeBase NewTimeBase(void)
 = {0x303C,0xA5,0xAAAA};
pascal void DisposeTimeBase(TimeBase tb)
 = {0x303C,0xB6,0xAAAA};

pascal TimeValue GetTimeBaseTime(TimeBase tb,TimeScale s,TimeRecord *out)
 = {0x303C,0xA6,0xAAAA};
pascal void SetTimeBaseTime(TimeBase tb,const TimeRecord *tr)
 = {0x303C,0xA7,0xAAAA};
pascal void SetTimeBaseValue(TimeBase tb,TimeValue t,TimeScale s)
 = {0x303C,0xA8,0xAAAA};

pascal Fixed GetTimeBaseRate(TimeBase tb)
 = {0x303C,0xA9,0xAAAA};
pascal void SetTimeBaseRate(TimeBase tb,Fixed r)
 = {0x303C,0xAA,0xAAAA};

pascal TimeValue GetTimeBaseStartTime(TimeBase tb,TimeScale s,TimeRecord *out)
 = {0x303C,0xAB,0xAAAA};
pascal void SetTimeBaseStartTime(TimeBase tb,const TimeRecord *tr)
 = {0x303C,0xAC,0xAAAA};
pascal TimeValue GetTimeBaseStopTime(TimeBase tb,TimeScale s,TimeRecord *out)
 = {0x303C,0xAD,0xAAAA};
pascal void SetTimeBaseStopTime(TimeBase tb,const TimeRecord *tr)
 = {0x303C,0xAE,0xAAAA};

pascal long GetTimeBaseFlags(TimeBase tb)
 = {0x303C,0xB1,0xAAAA};
pascal void SetTimeBaseFlags(TimeBase tb,long timeBaseFlags)
 = {0x303C,0xB2,0xAAAA};

pascal void SetTimeBaseMasterTimeBase(TimeBase slave,TimeBase master,const TimeRecord *slaveZero)
 = {0x303C,0xB4,0xAAAA};
pascal TimeBase GetTimeBaseMasterTimeBase(TimeBase tb)
 = {0x303C,0xAF,0xAAAA};
pascal void SetTimeBaseMasterClock(TimeBase slave,Component clockMeister,
 const TimeRecord *slaveZero)
 = {0x303C,0xB3,0xAAAA};
pascal ComponentInstance GetTimeBaseMasterClock(TimeBase tb)
 = {0x303C,0xB0,0xAAAA};

pascal void ConvertTime(TimeRecord *inout,TimeBase newBase)
 = {0x303C,0xB5,0xAAAA};
pascal void ConvertTimeScale(TimeRecord *inout,TimeScale newScale)
 = {0x303C,0xB7,0xAAAA};
pascal void AddTime(TimeRecord *dst,const TimeRecord *src)
 = {0x303C,0x10C,0xAAAA};
pascal void SubtractTime(TimeRecord *dst,const TimeRecord *src)
 = {0x303C,0x10D,0xAAAA};

pascal long GetTimeBaseStatus(TimeBase tb,TimeRecord *unpinnedTime)
 = {0x303C,0x10B,0xAAAA};

pascal void SetTimeBaseZero(TimeBase tb,TimeRecord *zero)
 = {0x303C,0x128,0xAAAA};

/*  CallBack Routines  */
pascal QTCallBack NewCallBack(TimeBase tb,short qtType)
 = {0x303C,0xEB,0xAAAA};

pascal void DisposeCallBack(QTCallBack qtCall)
 = {0x303C,0xEC,0xAAAA};

pascal short GetCallBackType(QTCallBack qtCall)
 = {0x303C,0xED,0xAAAA};
pascal TimeBase GetCallBackTimeBase(QTCallBack qtCall)
 = {0x303C,0xEE,0xAAAA};

pascal OSErr CallMeWhen(QTCallBack qtCall,QTCallBackProc callBackProc,long refCon,
 long param1,long param2,long param3)
 = {0x303C,0xB8,0xAAAA};

pascal void CancelCallBack(QTCallBack cb)
 = {0x303C,0xB9,0xAAAA};

/*  Clock CallBack support Routines  */
pascal OSErr AddCallBackToTimeBase(QTCallBack cb)
 = {0x303C,0x129,0xAAAA};
pascal OSErr RemoveCallBackFromTimeBase(QTCallBack cb)
 = {0x303C,0x12A,0xAAAA};
pascal QTCallBack GetFirstCallBack(TimeBase tb)
 = {0x303C,0x12B,0xAAAA};
pascal QTCallBack GetNextCallBack(QTCallBack cb)
 = {0x303C,0x12C,0xAAAA};
pascal void ExecuteCallBack(QTCallBack cb)
 = {0x303C,0x12D,0xAAAA};
#ifdef __cplusplus
}
#endif



/* Movie Controller Routines */

enum {mcActionIdle = 1,mcActionDraw,mcActionActivate,mcActionDeactivate,
 mcActionMouseDown,mcActionKey,mcActionStop,mcActionPlay,mcActionPlayBackwards,
 mcActionGotoStart,mcActionGotoEnd,mcActionGotoTime,mcActionMuteToggle,
 mcActionSetVolume,mcActionSetRate,mcActionIncreaseRate,mcActionDecreaseRate,
 mcActionStepForward,mcActionStepBackward,mcActionToggleLooping,mcActionSetLooping,
 mcActionGetLooping,mcActionSetLoopIsPalindrome,mcActionGetLoopIsPalindrome,
 mcActionSetGrowBoxBounds,mcActionControllerSizeChanged,mcActionIncreaseVolume,
 mcActionDecreaseVolume,mcActionSetSelectionBegin,mcActionSetSelectionDuration,
 mcActionSetPosterTime,mcActionSetKeysEnabled,mcActionGetKeysEnabled,
 mcActionSetPlaySelection,mcActionGetPlaySelection,mcActionSetUseBadge,
 mcActionGetUseBadge,mcActionSetFlags,mcActionGetFlags,
 mcActionSetPlayEveryFrame,mcActionGetPlayEveryFrame};
typedef unsigned short mcAction;

enum {mcFlagSuppressMovieFrame = 1<<0,mcFlagSuppressStepButtons = 1<<1,
 mcFlagSuppressSpeakerButton = 1<<2};


typedef pascal Boolean (*MCActionFilter)(MovieController mc,short *action,long param);

enum {mcTopLeftMovie = 1<<0,mcScaleMovieToFit = 1<<1};
typedef unsigned char mcCreationFlagsEnum;

enum {mcInfoUndoAvailable = 1<<0,mcInfoCutAvailable = 1<<1,mcInfoCopyAvailable = 1<<2,
 mcInfoPasteAvailable = 1<<3,mcInfoClearAvailable = 1<<4,mcInfoHasSound = 1<<5,
 mcInfoIsPlaying = 1<<6,mcInfoIsLooping = 1<<7,mcInfoIsInPalindrome = 1<<8,
 mcInfoEditingEnabled = 1<<9};
typedef unsigned short mcInfoFlagsEnum;


#ifdef __cplusplus
extern "C" {
#endif
/*  target management  */
pascal MovieController MCNewMovieController(Movie m,const Rect *movieRect,
 long controllerCreationFlags)
 = {0x303C,0x18A,0xAAAA};
pascal void MCDisposeMovieController(MovieController mc)
 = {0x303C,0x18B,0xAAAA};

pascal ComponentResult MCSetMovie(MovieController mc,Movie m,WindowPtr movieWindow,
 Point where)
 = {0x2F3C,0xC,0x2,0x7000,0xA82A};
pascal ComponentResult MCRemoveMovie(MovieController mc,Movie m)
 = {0x2F3C,0x4,0x3,0x7000,0xA82A};
pascal long MCCountMovies(MovieController mc)
 = {0x2F3C,0x0,0x4,0x7000,0xA82A};
pascal Movie MCGetIndMovie(MovieController mc,short index)
 = {0x2F3C,0x2,0x5,0x7000,0xA82A};
pascal ComponentResult MCRemoveAllMovies(MovieController mc)
 = {0x2F3C,0x0,0x6,0x7000,0xA82A};

/*  event handling etc.  */
pascal ComponentResult MCIsPlayerEvent(MovieController mc,const EventRecord *e)
 = {0x2F3C,0x4,0x7,0x7000,0xA82A};
pascal ComponentResult MCSetActionFilter(MovieController mc,MCActionFilter filter)
 = {0x2F3C,0x4,0x8,0x7000,0xA82A};
pascal ComponentResult MCDoAction(MovieController mc,short action,void *params)
 = {0x2F3C,0x6,0x9,0x7000,0xA82A};

/*  state type things  */
pascal ComponentResult MCSetControllerAttached(MovieController mc,Boolean attach)
 = {0x2F3C,0x2,0xA,0x7000,0xA82A};
pascal ComponentResult MCIsControllerAttached(MovieController mc)
 = {0x2F3C,0x0,0xB,0x7000,0xA82A};
pascal ComponentResult MCSetControllerPort(MovieController mc,CGrafPtr gp)
 = {0x2F3C,0x4,0xC,0x7000,0xA82A};
pascal CGrafPtr MCGetControllerPort(MovieController mc)
 = {0x2F3C,0x0,0xD,0x7000,0xA82A};

pascal ComponentResult MCSetVisible(MovieController mc,Boolean show)
 = {0x2F3C,0x2,0xE,0x7000,0xA82A};
pascal ComponentResult MCGetVisible(MovieController mc)
 = {0x2F3C,0x0,0xF,0x7000,0xA82A};

pascal ComponentResult MCGetControllerBoundsRect(MovieController mc,Rect *bounds)
 = {0x2F3C,0x4,0x10,0x7000,0xA82A};
pascal ComponentResult MCSetControllerBoundsRect(MovieController mc,const Rect *bounds)
 = {0x2F3C,0x4,0x11,0x7000,0xA82A};
pascal RgnHandle MCGetControllerBoundsRgn(MovieController mc)
 = {0x2F3C,0x0,0x12,0x7000,0xA82A};
pascal RgnHandle MCGetWindowRgn(MovieController mc,WindowPtr w)
 = {0x2F3C,0x4,0x13,0x7000,0xA82A};

/*  other stuff  */
pascal ComponentResult MCMovieChanged(MovieController mc,Movie m)
 = {0x2F3C,0x4,0x14,0x7000,0xA82A};
pascal ComponentResult MCSetDuration(MovieController mc,TimeValue duration)
 = {0x2F3C,0x4,0x15,0x7000,0xA82A};
pascal TimeValue MCGetCurrentTime(MovieController mc,TimeScale *scale)
 = {0x2F3C,0x4,0x16,0x7000,0xA82A};
pascal ComponentResult MCNewAttachedController(MovieController mc,Movie m,
 WindowPtr w,Point where)
 = {0x2F3C,0xC,0x17,0x7000,0xA82A};
pascal ComponentResult MCPositionController(MovieController mc,Rect *movieRect,
 Rect *controllerRect,long controllerCreationFlags)
 = {0x2F3C,0xC,0x24,0x7000,0xA82A};

/*  direct event handlers  */
pascal ComponentResult MCDraw(MovieController mc,WindowPtr w)
 = {0x2F3C,0x4,0x18,0x7000,0xA82A};
pascal ComponentResult MCActivate(MovieController mc,WindowPtr w,Boolean activate)
 = {0x2F3C,0x6,0x19,0x7000,0xA82A};
pascal ComponentResult MCIdle(MovieController mc)
 = {0x2F3C,0x0,0x1A,0x7000,0xA82A};
pascal ComponentResult MCKey(MovieController mc,char key,long modifiers)
 = {0x2F3C,0x6,0x1B,0x7000,0xA82A};
pascal ComponentResult MCClick(MovieController mc,WindowPtr w,Point where,
 long when,long modifiers)
 = {0x2F3C,0x10,0x1C,0x7000,0xA82A};

/*   calls for editing  */
pascal ComponentResult MCEnableEditing(MovieController mc,Boolean enabled)
 = {0x2F3C,0x2,0x1D,0x7000,0xA82A};
pascal long MCIsEditingEnabled(MovieController mc)
 = {0x2F3C,0x0,0x1E,0x7000,0xA82A};
pascal Movie MCCopy(MovieController mc)
 = {0x2F3C,0x0,0x1F,0x7000,0xA82A};
pascal Movie MCCut(MovieController mc)
 = {0x2F3C,0x0,0x20,0x7000,0xA82A};
pascal ComponentResult MCPaste(MovieController mc,Movie srcMovie)
 = {0x2F3C,0x4,0x21,0x7000,0xA82A};
pascal ComponentResult MCClear(MovieController mc)
 = {0x2F3C,0x0,0x22,0x7000,0xA82A};
pascal ComponentResult MCUndo(MovieController mc)
 = {0x2F3C,0x0,0x23,0x7000,0xA82A};

/*  menu related stuff  */
pascal ComponentResult MCGetControllerInfo(MovieController mc,long *mcInfoFlags)
 = {0x2F3C,0x4,0x25,0x7000,0xA82A};

pascal ComponentResult MCSetClip(MovieController mc, RgnHandle theClip, RgnHandle movieClip)
= {0x2f3c,8,40,0x7000,0xa82a};
pascal ComponentResult MCGetClip(MovieController mc, RgnHandle *theClip, RgnHandle *movieClip)
= {0x2f3c,8,41,0x7000,0xa82a};

pascal ComponentResult MCDrawBadge(MovieController mc, RgnHandle movieRgn, RgnHandle *badgeRgn)
= {0x2f3c,8,42,0x7000,0xa82a};

#ifdef __cplusplus
}
#endif
enum {


/* movie controller error codes */
 cannotMoveAttachedController = -9999,
 controllerHasFixedHeight = -9998,
 cannotSetWidthOfAttachedController = -9997,
 controllerBoundsNotExact = -9996,
 editingNotAllowed = -9995,
 badControllerHeight = -9994
};


#endif